package maple.thelittleredbook.interaction.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import maple.thelittleredbook.interaction.dto.CommentListItemDTO;
import maple.thelittleredbook.interaction.dto.CommentListResponse;
import maple.thelittleredbook.interaction.mapper.CommentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 评论服务
 * 负责评论的增删改查业务逻辑
 */
@Slf4j
@Service
public class CommentService {

    private final CommentMapper commentMapper;
    private final AsyncUserBehaviorService asyncUserBehaviorService;

    @Autowired
    public CommentService(CommentMapper commentMapper,
                          AsyncUserBehaviorService asyncUserBehaviorService) {
        this.commentMapper = commentMapper;
        this.asyncUserBehaviorService = asyncUserBehaviorService;
    }

    /**
     * 分页获取评论列表
     *
     * @param pageNum 页码
     * @param pageSize 每页数量
     * @param contentId 内容ID
     * @param orderBy 排序方式
     * @param currentUserId 当前用户ID（用于查询点赞状态，可以为null）
     * @return 评论列表响应
     */
    public CommentListResponse getCommentList(Integer pageNum, Integer pageSize,
                                              Long contentId, String orderBy, Long currentUserId) {
        // 1. 参数验证和默认值设置
        pageNum = pageNum != null && pageNum > 0 ? pageNum : 1;
        pageSize = pageSize != null && pageSize > 0 && pageSize <= 100 ? pageSize : 20;
        orderBy = orderBy != null && !orderBy.trim().isEmpty() ? orderBy : "created_at";

        log.info("查询评论列表，内容ID: {}, 当前用户ID: {}, 页码: {}, 每页数量: {}, 排序: {}",
                contentId, currentUserId, pageNum, pageSize, orderBy);

        // 2. 创建分页对象
        Page<CommentListItemDTO> page = new Page<>(pageNum, pageSize);

        // 3. 处理排序参数
        String finalOrderBy = "like_count".equals(orderBy) ? "like_count" : "created_at";

        // 4. 查询数据库
        IPage<CommentListItemDTO> result = commentMapper.selectCommentsByContentId(
                page, contentId, currentUserId, finalOrderBy);

        // 5. 构建响应对象
        return buildCommentListResponse(result, pageNum, pageSize);
    }

    /**
     * 创建评论
     * 同步方法 - 直接返回结果给前端
     *
     * @param contentId 内容ID
     * @param userId 用户ID
     * @param commentText 评论内容
     */
    @Transactional
    public void createComment(Long contentId, Long userId, String commentText) {
        try {
            log.info("开始创建评论，用户ID: {}, 内容ID: {}, 评论内容长度: {}",
                    userId, contentId, commentText != null ? commentText.length() : 0);

            // 1. 参数验证
            validateCommentRequest(contentId, userId, commentText);

            // 2. 插入评论记录
            int insertResult = commentMapper.insertComment(contentId, userId, commentText);
            if (insertResult <= 0) {
                throw new RuntimeException("插入评论失败");
            }

            log.info("评论创建成功，用户ID: {}, 内容ID: {}", userId, contentId);

            // 3. 异步处理用户行为（记录评论行为 + 更新评论数 + 更新用户画像）
            asyncUserBehaviorService.processCommentBehaviorAsync(userId, contentId);

        } catch (IllegalArgumentException e) {
            log.error("创建评论参数错误，用户ID: {}, 内容ID: {}, 错误: {}", userId, contentId, e.getMessage());
            throw e;
        } catch (Exception e) {
            log.error("创建评论失败，用户ID: {}, 内容ID: {}", userId, contentId, e);
            throw new RuntimeException("创建评论失败: " + e.getMessage());
        }
    }

    /**
     * 删除评论（逻辑删除）
     * 同步方法
     *
     * @param commentId 评论ID
     * @param userId 用户ID
     * @param isAdmin 是否为管理员
     * @return 是否删除成功
     */
    @Transactional
    public boolean deleteComment(Long commentId, Long userId, boolean isAdmin) {
        try {
            log.info("开始删除评论，用户ID: {}, 评论ID: {}, 是否管理员: {}", userId, commentId, isAdmin);

            // 1. 参数验证
            if (commentId == null || userId == null) {
                throw new IllegalArgumentException("评论ID和用户ID不能为空");
            }

            int updateResult;

            if (isAdmin) {
                // 2. 管理员可以删除任意评论
                updateResult = commentMapper.updateCommentDeletedByAdmin(commentId);
                if (updateResult > 0) {
                    log.info("管理员删除评论成功，管理员ID: {}, 评论ID: {}", userId, commentId);
                } else {
                    log.warn("管理员删除评论失败，可能评论不存在或已删除，管理员ID: {}, 评论ID: {}", userId, commentId);
                }
            } else {
                // 3. 普通用户只能删除自己的评论
                updateResult = commentMapper.updateCommentDeleted(commentId, userId);
                if (updateResult > 0) {
                    log.info("用户删除评论成功，用户ID: {}, 评论ID: {}", userId, commentId);
                } else {
                    log.warn("用户删除评论失败，可能评论不存在或无权限删除，用户ID: {}, 评论ID: {}", userId, commentId);
                }
            }

            return updateResult > 0;

        } catch (IllegalArgumentException e) {
            log.error("删除评论参数错误，用户ID: {}, 评论ID: {}, 错误: {}", userId, commentId, e.getMessage());
            throw e;
        } catch (Exception e) {
            log.error("删除评论失败，用户ID: {}, 评论ID: {}", userId, commentId, e);
            throw new RuntimeException("删除评论失败: " + e.getMessage());
        }
    }

    /**
     * 构建评论列表响应对象
     */
    private CommentListResponse buildCommentListResponse(IPage<CommentListItemDTO> result,
                                                         Integer pageNum, Integer pageSize) {
        CommentListResponse response = new CommentListResponse();
        response.setTotal(result.getTotal());
        response.setTotalPages((int) Math.ceil((double) result.getTotal() / pageSize));
        response.setPageNum(pageNum);
        response.setPageSize(pageSize);
        response.setComments(result.getRecords());

        log.info("评论列表查询完成，总记录数: {}, 当前页记录数: {}", result.getTotal(), result.getRecords().size());

        return response;
    }

    /**
     * 验证评论请求参数
     */
    private void validateCommentRequest(Long contentId, Long userId, String commentText) {
        if (contentId == null) {
            throw new IllegalArgumentException("内容ID不能为空");
        }

        if (userId == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }

        if (commentText == null || commentText.trim().isEmpty()) {
            throw new IllegalArgumentException("评论内容不能为空");
        }

        if (commentText.length() > 500) {
            throw new IllegalArgumentException("评论内容不能超过500字符");
        }
    }
}